Type-veilige API-aanroepen met TypeScript: Een Uitgebreide Gids

In moderne webontwikkeling is het communiceren met API's een fundamentele taak. TypeScript, met zijn krachtige typesysteem, biedt een aanzienlijk voordeel bij het waarborgen van de betrouwbaarheid en onderhoudbaarheid van uw applicaties door type-veilige API-aanroepen mogelijk te maken. Deze gids onderzoekt hoe u de functies van TypeScript kunt benutten om robuuste en foutloze API-interacties te bouwen, met aandacht voor best practices, geavanceerde technieken en praktijkvoorbeelden.

Waarom Typesafety Belangrijk is voor API-aanroepen

Bij het werken met API's heeft u te maken met gegevens die afkomstig zijn van een externe bron. Deze gegevens zijn mogelijk niet altijd in de verwachte vorm, wat kan leiden tot runtimefouten en onverwacht gedrag. Typesafety biedt een cruciale beschermingslaag door te verifiëren dat de gegevens die u ontvangt voldoen aan een vooraf gedefinieerde structuur, waardoor potentiële problemen vroeg in het ontwikkelproces worden opgevangen.

• Verminderde Runtimefouten: Typecontrole tijdens compilatie helpt fouten gerelateerd aan types te identificeren en te corrigeren voordat ze de productie bereiken.
• Verbeterde Codeonderhoudbaarheid: Duidelijke type definities maken uw code gemakkelijker te begrijpen en te wijzigen, waardoor het risico op het introduceren van bugs tijdens refactoring wordt verminderd.
• Verbeterde Codeleesbaarheid: Type-annotaties bieden waardevolle documentatie, waardoor het voor ontwikkelaars gemakkelijker wordt om de verwachte gegevensstructuren te begrijpen.
• Betere Ontwikkelaarservaring: IDE-ondersteuning voor typecontrole en autocompletie verbetert de ontwikkelaarservaring aanzienlijk en vermindert de kans op fouten.

Uw TypeScript-project Instellen

Voordat u zich verdiept in API-aanroepen, moet u ervoor zorgen dat uw TypeScript-project is ingesteld. Als u vanaf nul begint, kunt u een nieuw project initialiseren met:

            npm init -y
npm install typescript --save-dev
tsc --init
            

              
                Copy
              
            
          

Dit creëert een `tsconfig.json`-bestand met standaard TypeScript-compileropties. U kunt deze opties aanpassen aan de behoeften van uw project. U kunt bijvoorbeeld de strikte modus inschakelen voor strengere typecontrole:

            // tsconfig.json
{
  "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

            

              
                Copy
              
            
          

Typen Definiëren voor API-reacties

De eerste stap om type-veilige API-aanroepen te bereiken, is het definiëren van TypeScript-typen die de structuur van de gegevens vertegenwoordigen die u van de API verwacht te ontvangen. Dit gebeurt meestal met `interface`- of `type`-declaraties.

Interfaces Gebruiken

Interfaces zijn een krachtige manier om de vorm van een object te definiëren. Als u bijvoorbeeld een lijst met gebruikers van een API haalt, kunt u een interface als volgt definiëren:

            interface User {
  id: number;
  name: string;
  email: string;
  address?: string; // Optioneel veld
  phone?: string; // Optioneel veld
  website?: string; // Optioneel veld
  company?: {
    name: string;
    catchPhrase: string;
    bs: string;
  };
}

            

              
                Copy
              
            
          

De `?` na een veldnaam geeft aan dat het veld optioneel is. Dit is handig voor het verwerken van API-reacties waarbij bepaalde velden ontbreken.

Typen Gebruiken

Typen zijn vergelijkbaar met interfaces, maar bieden meer flexibiliteit, waaronder de mogelijkheid om union- en intersection-typen te definiëren. U kunt hetzelfde resultaat bereiken als met de bovenstaande interface met behulp van een type:

            type User = {
  id: number;
  name: string;
  email: string;
  address?: string; // Optioneel veld
  phone?: string; // Optioneel veld
  website?: string; // Optioneel veld
  company?: {
    name: string;
    catchPhrase: string;
    bs: string;
  };
};

            

              
                Copy
              
            
          

Voor eenvoudige objectstructuren zijn interfaces en typen vaak uitwisselbaar. Typen worden echter krachtiger bij het omgaan met complexere scenario's.

API-aanroepen Maken met Axios

Axios is een populaire HTTP-client voor het maken van API-verzoeken in JavaScript en TypeScript. Het biedt een schone en intuïtieve API, waardoor het gemakkelijk is om verschillende HTTP-methoden, request headers en responsegegevens te verwerken.

Axios Installeren

            npm install axios
            

              
                Copy
              
            
          

Een Getypeerde API-aanroep Maken

Om een type-veilige API-aanroep met Axios te maken, kunt u de `axios.get`-methode gebruiken en het verwachte responstype specificeren met behulp van generics:

            import axios from 'axios';

async function fetchUsers(): Promise<User[]> {
  try {
    const response = await axios.get<User[]>('https://jsonplaceholder.typicode.com/users');
    return response.data;
  } catch (error) {
    console.error('Fout bij het ophalen van gebruikers:', error);
    throw error;
  }
}

fetchUsers().then(users => {
  users.forEach(user => {
    console.log(user.name);
  });
});
            

              
                Copy
              
            
          

In dit voorbeeld vertelt `axios.get<User[]>('...')` aan TypeScript dat de responsegegevens naar verwachting een array van `User`-objecten zullen zijn. Hierdoor kan TypeScript typecontrole en autocompletie bieden bij het werken met de responsegegevens.

Verschillende HTTP-methoden Verwerken

Axios ondersteunt verschillende HTTP-methoden, waaronder `GET`, `POST`, `PUT`, `DELETE` en `PATCH`. U kunt de bijbehorende methoden gebruiken om verschillende soorten API-aanroepen te maken. Om bijvoorbeeld een nieuwe gebruiker aan te maken, kunt u de `axios.post`-methode gebruiken:

            async function createUser(user: Omit<User, 'id'>): Promise<User> {
  try {
    const response = await axios.post<User>('https://jsonplaceholder.typicode.com/users', user);
    return response.data;
  } catch (error) {
    console.error('Fout bij het aanmaken van gebruiker:', error);
    throw error;
  }
}

const newUser = {
  name: 'John Doe',
  email: 'john.doe@example.com',
  address: '123 Main St',
  phone: '555-1234',
  website: 'example.com',
  company: {
    name: 'Example Corp',
    catchPhrase: 'Leading the way',
    bs: 'Innovative solutions'
  }
};

createUser(newUser).then(user => {
  console.log('Aangemaakte gebruiker:', user);
});
            

              
                Copy
              
            
          

In dit voorbeeld creëert `Omit<User, 'id'>` een type dat hetzelfde is als `User`, maar zonder de `id`-eigenschap. Dit is handig omdat de `id` doorgaans door de server wordt gegenereerd bij het aanmaken van een nieuwe gebruiker.

De Fetch API Gebruiken

De Fetch API is een ingebouwde JavaScript API voor het maken van HTTP-verzoeken. Hoewel het basaler is dan Axios, kan het ook met TypeScript worden gebruikt om type-veilige API-aanroepen te realiseren. U kunt het verkiezen om een afhankelijkheid te vermijden als het aan uw behoeften voldoet.

Een Getypeerde API-aanroep Maken met Fetch

Om een type-veilige API-aanroep met Fetch te maken, kunt u de `fetch`-functie gebruiken en vervolgens de respons als JSON parsen, waarbij u het verwachte responstype specificeert:

            async function fetchUsers(): Promise<User[]> {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/users');
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data: User[] = await response.json();
    return data;
  } catch (error) {
    console.error('Fout bij het ophalen van gebruikers:', error);
    throw error;
  }
}

fetchUsers().then(users => {
  users.forEach(user => {
    console.log(user.name);
  });
});
            

              
                Copy
              
            
          

In dit voorbeeld vertelt `const data: User[] = await response.json();` aan TypeScript dat de responsegegevens moeten worden behandeld als een array van `User`-objecten. Hierdoor kan TypeScript typecontrole en autocompletie uitvoeren.

Verschillende HTTP-methoden Verwerken met Fetch

Om verschillende soorten API-aanroepen met Fetch te maken, kunt u de `fetch`-functie gebruiken met verschillende opties, zoals de opties `method` en `body`. Om bijvoorbeeld een nieuwe gebruiker aan te maken, kunt u de volgende code gebruiken:

            async function createUser(user: Omit<User, 'id'>): Promise<User> {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/users', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(user)
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data: User = await response.json();
    return data;
  } catch (error) {
    console.error('Fout bij het aanmaken van gebruiker:', error);
    throw error;
  }
}

const newUser = {
  name: 'John Doe',
  email: 'john.doe@example.com',
  address: '123 Main St',
  phone: '555-1234',
  website: 'example.com',
  company: {
    name: 'Example Corp',
    catchPhrase: 'Leading the way',
    bs: 'Innovative solutions'
  }
};

createUser(newUser).then(user => {
  console.log('Aangemaakte gebruiker:', user);
});
            

              
                Copy
              
            
          

API-fouten Verwerken

Foutafhandeling is een cruciaal aspect van API-aanroepen. API's kunnen om vele redenen falen, waaronder problemen met de netwerkverbinding, serverfouten en ongeldige verzoeken. Het is essentieel om deze fouten netjes af te handelen om te voorkomen dat uw applicatie crasht of onverwacht gedrag vertoont.

Try-Catch Blokken Gebruiken

De meest gebruikelijke manier om fouten in asynchrone code af te handelen, is door try-catch blokken te gebruiken. Hiermee kunt u eventuele uitzonderingen die worden gegenereerd tijdens de API-aanroep opvangen en ze correct afhandelen.

            async function fetchUsers(): Promise<User[]> {
  try {
    const response = await axios.get<User[]>('https://jsonplaceholder.typicode.com/users');
    return response.data;
  } catch (error) {
    console.error('Fout bij het ophalen van gebruikers:', error);
    // Behandel de fout, bijv. toon een foutmelding aan de gebruiker
    throw error; // Gooi de fout opnieuw om de aanroepende code deze ook te laten afhandelen
  }
}
            

              
                Copy
              
            
          

Specifieke Foutcodes Verwerken

API's retourneren vaak specifieke foutcodes om het type fout aan te geven dat is opgetreden. U kunt deze foutcodes gebruiken om specifiekere foutafhandeling te bieden. U wilt bijvoorbeeld mogelijk een andere foutmelding weergeven voor een 404 Not Found-fout dan voor een 500 Internal Server Error.

            async function fetchUser(id: number): Promise<User | null> {
  try {
    const response = await axios.get<User>(`https://jsonplaceholder.typicode.com/users/${id}`);
    return response.data;
  } catch (error: any) {
    if (error.response?.status === 404) {
      console.log(`Gebruiker met ID ${id} niet gevonden.`);
      return null; // Of gooi een aangepaste fout
    } else {
      console.error('Fout bij het ophalen van gebruiker:', error);
      throw error;
    }
  }
}

fetchUser(123).then(user => {
  if (user) {
    console.log('Gebruiker:', user);
  } else {
    console.log('Gebruiker niet gevonden.');
  }
});
            

              
                Copy
              
            
          

Aangepaste Fouttypen Creëren

Voor complexere foutafhandelingscenario's kunt u aangepaste fouttypen creëren om verschillende soorten API-fouten te vertegenwoordigen. Hierdoor kunt u meer gestructureerde foutinformatie bieden en fouten effectiever afhandelen.

            class ApiError extends Error {
  constructor(public statusCode: number, message: string) {
    super(message);
    this.name = 'ApiError';
  }
}

async function fetchUser(id: number): Promise<User> {
  try {
    const response = await axios.get<User>(`https://jsonplaceholder.typicode.com/users/${id}`);
    return response.data;
  } catch (error: any) {
    if (error.response?.status === 404) {
      throw new ApiError(404, `Gebruiker met ID ${id} niet gevonden.`);
    } else {
      console.error('Fout bij het ophalen van gebruiker:', error);
      throw new ApiError(500, 'Interne Serverfout'); // Of een andere geschikte statuscode
    }
  }
}

fetchUser(123).catch(error => {
  if (error instanceof ApiError) {
    console.error(`API Fout: ${error.statusCode} - ${error.message}`);
  } else {
    console.error('Een onverwachte fout is opgetreden:', error);
  }
});
            

              
                Copy
              
            
          

Data Validatie

Zelfs met het typesysteem van TypeScript is het cruciaal om de gegevens die u van API's ontvangt tijdens runtime te valideren. API's kunnen hun responstructuur zonder kennisgeving wijzigen en uw TypeScript-typen zijn mogelijk niet altijd perfect gesynchroniseerd met de daadwerkelijke respons van de API.

Zod Gebruiken voor Runtime Validatie

Zod is een populaire TypeScript-bibliotheek voor runtime data validatie. Het stelt u in staat schema's te definiëren die de verwachte structuur van uw gegevens beschrijven en vervolgens de gegevens te valideren tegen die schema's tijdens runtime.

Zod Installeren

            npm install zod
            

              
                Copy
              
            
          

API-reacties Valideren met Zod

Om API-reacties met Zod te valideren, kunt u een Zod-schema definiëren dat overeenkomt met uw TypeScript-type en vervolgens de `parse`-methode gebruiken om de gegevens te valideren.

            import { z } from 'zod';

const userSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
  address: z.string().optional(),
  phone: z.string().optional(),
  website: z.string().optional(),
  company: z.object({
    name: z.string(),
    catchPhrase: z.string(),
    bs: z.string(),
  }).optional(),
});

type User = z.infer<typeof userSchema>;

async function fetchUsers(): Promise<User[]> {
  try {
    const response = await axios.get<unknown>('https://jsonplaceholder.typicode.com/users');
    const data = z.array(userSchema).parse(response.data);
    return data;
  } catch (error) {
    console.error('Fout bij het ophalen van gebruikers:', error);
    throw error;
  }
}

            

              
                Copy
              
            
          

In dit voorbeeld valideert `z.array(userSchema).parse(response.data)` dat de responsegegevens een array van objecten zijn die voldoen aan het `userSchema`. Als de gegevens niet voldoen aan het schema, gooit Zod een fout, die u vervolgens correct kunt afhandelen.

Geavanceerde Technieken

Generics Gebruiken voor Herbruikbare API-functies

Generics stellen u in staat om herbruikbare API-functies te schrijven die verschillende soorten gegevens kunnen verwerken. U kunt bijvoorbeeld een generieke `fetchData`-functie maken die gegevens van elke API-endpoint kan ophalen en deze met het juiste type kan retourneren.

            async function fetchData<T>(url: string): Promise<T> {
  try {
    const response = await axios.get<T>(url);
    return response.data;
  } catch (error) {
    console.error(`Fout bij het ophalen van gegevens van ${url}:`, error);
    throw error;
  }
}

// Gebruik
fetchData<User[]>('https://jsonplaceholder.typicode.com/users').then(users => {
  console.log('Gebruikers:', users);
});

fetchData<{ title: string; body: string }>('https://jsonplaceholder.typicode.com/todos/1').then(todo => {
    console.log('Todo', todo)
});

            

              
                Copy
              
            
          

Interceptors Gebruiken voor Globale Foutafhandeling

Axios biedt interceptors waarmee u requests en responses kunt onderscheppen voordat ze door uw code worden verwerkt. U kunt interceptors gebruiken om globale foutafhandeling te implementeren, zoals het loggen van fouten of het weergeven van foutmeldingen aan de gebruiker.

            axios.interceptors.response.use(
  (response) => response,
  (error) => {
    console.error('Globale foutafhandelaar:', error);
    // Toon een foutmelding aan de gebruiker
    return Promise.reject(error);
  }
);

            

              
                Copy
              
            
          

Omgevingsvariabelen Gebruiken voor API-URL's

Om het hardcoderen van API-URL's in uw code te vermijden, kunt u omgevingsvariabelen gebruiken om de URL's op te slaan. Dit maakt het gemakkelijker om uw applicatie te configureren voor verschillende omgevingen, zoals ontwikkeling, staging en productie.

Voorbeeld met `.env`-bestand en `dotenv`-pakket.

            // .env
API_URL=https://api.example.com

            

              
                Copy
              
            
          

            // Installeer dotenv
npm install dotenv

            

              
                Copy
              
            
          

            // Importeer en configureer dotenv
import * as dotenv from 'dotenv'
dotenv.config()

const apiUrl = process.env.API_URL || 'http://localhost:3000'; // geef een standaardwaarde

async function fetchData<T>(endpoint: string): Promise<T> {
  try {
    const response = await axios.get<T>(`${apiUrl}/${endpoint}`);
    return response.data;
  } catch (error) {
    console.error(`Fout bij het ophalen van gegevens van ${apiUrl}/${endpoint}:`, error);
    throw error;
  }
}

            

              
                Copy
              
            
          

Conclusie

Type-veilige API-aanroepen zijn essentieel voor het bouwen van robuuste, onderhoudbare en foutloze webapplicaties. TypeScript biedt krachtige functies waarmee u typen kunt definiëren voor API-reacties, gegevens tijdens runtime kunt valideren en fouten netjes kunt afhandelen. Door de best practices en technieken in deze gids te volgen, kunt u de kwaliteit en betrouwbaarheid van uw API-interacties aanzienlijk verbeteren.

Door TypeScript en bibliotheken zoals Axios en Zod te gebruiken, kunt u ervoor zorgen dat uw API-aanroepen type-veilig zijn, uw gegevens worden gevalideerd en uw fouten netjes worden afgehandeld. Dit zal leiden tot robuustere en beter onderhoudbare applicaties.

Vergeet niet uw gegevens altijd runtime te valideren, zelfs met het typesysteem van TypeScript. API's kunnen veranderen en uw typen zijn mogelijk niet altijd perfect gesynchroniseerd met de daadwerkelijke respons van de API. Door uw gegevens runtime te valideren, kunt u potentiële problemen opvangen voordat ze problemen veroorzaken in uw applicatie.

Veel codeerplezier!